from atlassian import Confluence
import datetime
from pprint import pprint
import pandas as pd
import os
from typing import List, Dict, Any, Tuple
import argparse
import json
from calendar import monthrange
from bs4 import BeautifulSoup
import concurrent.futures
from tqdm import tqdm
import threading
from queue import Queue

class ConfluenceConfig:
    """Confluence配置类"""
    def __init__(self, url: str, token: str, space_key: str):
        """
        初始化Confluence配置
        
        Args:
            url: Confluence的URL
            token: 访问令牌
            space_key: 空间键
        """
        self.url = url
        self.token = token
        self.space_key = space_key
    
    @classmethod
    def from_json(cls, json_file: str = 'config.json') -> 'ConfluenceConfig':
        """
        从JSON文件加载配置
        
        Args:
            json_file: JSON配置文件路径
            
        Returns:
            ConfluenceConfig: 配置对象
        """
        try:
            with open(json_file, 'r', encoding='utf-8') as f:
                config = json.load(f)
                confluence_config = config.get('confluence', {})
                return cls(
                    url=confluence_config.get('url'),
                    token=confluence_config.get('token'),
                    space_key=confluence_config.get('space_key')
                )
        except Exception as e:
            raise Exception(f"读取配置文件失败: {str(e)}")

class ConfluenceClient:
    """Confluence客户端类，处理与Confluence的所有交互"""
    
    def __init__(self, config: ConfluenceConfig):
        """
        初始化Confluence客户端
        
        Args:
            config: Confluence配置对象
        """
        self.config = config
        self.client = Confluence(url=config.url, token=config.token)
        self.output_dir = None
    
    def set_output_dir(self, output_dir: str) -> None:
        """
        设置输出目录
        
        Args:
            output_dir: 输出目录路径
        """
        self.output_dir = output_dir
    
    def get_space_info(self) -> Dict:
        """
        获取空间信息
        
        Returns:
            Dict: 空间信息字典
        """
        try:
            space_info = self.client.get_space(self.config.space_key)
            return space_info
        except Exception as e:
            print(f"获取空间信息时发生错误：{str(e)}")
            return {}
    
    def get_all_pages(self) -> List[Dict]:
        """
        获取空间下的所有页面
        
        Returns:
            List[Dict]: 页面列表
        """
        try:
            pages = self.client.get_all_pages_from_space(self.config.space_key, start=0, limit=200)
            return pages
        except Exception as e:
            print(f"获取页面列表时发生错误：{str(e)}")
            return []
    
    def get_page_history(self, page_id: str) -> Dict:
        """
        获取页面的历史记录
        
        Args:
            page_id: 页面ID
            
        Returns:
            Dict: 页面历史记录
        """
        try:
            return self.client.history(page_id)
        except Exception as e:
            print(f"获取页面历史记录时发生错误：{str(e)}")
            return {}
    
    def get_page_tree(self) -> Tuple[str, str]:
        """
        获取并打印空间的页面树形结构，同时保存到文件
        
        Returns:
            Tuple[str, str]: (基础树形结构文件路径, 带节点计数的树形结构文件路径)
        """
        try:
            # 获取所有页面
            pages = self.get_all_pages()
            if not pages:
                print("未找到任何页面")
                return "", ""

            # 构建页面字典，key为页面ID
            pages_dict = {page['id']: page for page in pages}
            
            # 构建父子关系
            children = {}
            root_pages = []
            
            for page in pages:
                # 获取页面的父页面信息
                parent = self.client.get_page_by_id(page['id'], expand='ancestors')
                ancestors = parent.get('ancestors', [])
                
                if not ancestors:
                    # 没有父页面，即为根页面
                    root_pages.append(page)
                else:
                    # 获取直接父页面ID
                    parent_id = ancestors[-1]['id']
                    if parent_id not in children:
                        children[parent_id] = []
                    children[parent_id].append(page)
            
            # 使用已设置的输出目录
            if not self.output_dir:
                current_time = datetime.datetime.now().strftime("%Y%m%d_%H%M%S")
                self.output_dir = f"confluence_exports_{current_time}"
                os.makedirs(self.output_dir, exist_ok=True)
            
            # 创建基础树形结构文件
            current_time = datetime.datetime.now().strftime("%Y%m%d_%H%M%S")
            tree_file = os.path.join(self.output_dir, f"软件IP认证所页面结构_{current_time}.txt")
            tree_with_count_file = os.path.join(self.output_dir, f"软件IP认证所页面结构_带节点计数_{current_time}.txt")
            
            # 计算每个节点的子孙节点总数
            def count_descendants(page_id: str) -> int:
                if page_id not in children:
                    return 0
                count = len(children[page_id])
                for child in children[page_id]:
                    count += count_descendants(child['id'])
                return count
            
            # 递归打印树形结构
            def print_tree(pages: List[Dict], level: int = 0, prefix: str = "", with_count: bool = False) -> None:
                pages = sorted(pages, key=lambda x: x['title'])
                for i, page in enumerate(pages):
                    is_last = i == len(pages) - 1
                    current_prefix = "└── " if is_last else "├── "
                    
                    # 计算节点数量（如果需要）
                    count_text = ""
                    if with_count:
                        descendants_count = count_descendants(page['id'])
                        if descendants_count > 0:
                            count_text = f" [{descendants_count}]"
                    
                    line = f"{prefix}{current_prefix}{page['title']}{count_text}\n"
                    current_file.write(line)
                    
                    if page['id'] in children:
                        next_prefix = prefix + ("    " if is_last else "│   ")
                        print_tree(children[page['id']], level + 1, next_prefix, with_count)
            
            # 打印基础树形结构
            with open(tree_file, 'w', encoding='utf-8') as current_file:
                # 写入标题
                header = f"{self.config.space_key} 空间的页面结构：\n"
                header += "=" * 50 + "\n"
                current_file.write(header)
                print_tree(root_pages)
            
            # 打印带节点计数的树形结构
            with open(tree_with_count_file, 'w', encoding='utf-8') as current_file:
                # 写入标题
                header = f"{self.config.space_key} 空间的页面结构（带节点计数）：\n"
                header += "注：方括号中的数字表示该节点下所有子节点和孙节点的总数\n"
                header += "=" * 50 + "\n"
                current_file.write(header)
                print_tree(root_pages, with_count=True)
            
            return tree_file, tree_with_count_file
            
        except Exception as e:
            print(f"获取页面树形结构时发生错误：{str(e)}")
            return "", ""

    def get_content_diff(self, page_id: str, source_version: int, target_version: int) -> Dict:
        """
        获取页面两个版本之间的内容差异
        
        Args:
            page_id: 页面ID
            source_version: 源版本号
            target_version: 目标版本号
            
        Returns:
            Dict: 包含差异信息的字典
        """
        try:
            # 获取页面版本内容
            source = self.client.get_page_by_id(
                page_id, 
                expand='body.storage,version',
                status='historical',
                version=source_version
            )
            target = self.client.get_page_by_id(
                page_id,
                expand='body.storage,version',
                version=target_version
            )
            
            # 提取内容
            source_content = source.get('body', {}).get('storage', {}).get('value', '')
            target_content = target.get('body', {}).get('storage', {}).get('value', '')
            
            # 如果内容相同，返回空
            if source_content == target_content:
                return {'changes': '无修改'}
            
            # 解析HTML内容
            source_soup = BeautifulSoup(source_content, 'html.parser')
            target_soup = BeautifulSoup(target_content, 'html.parser')
            
            # 获取纯文本内容
            source_text = source_soup.get_text()
            target_text = target_soup.get_text()
            
            # 比较差异
            changes = []
            
            # 如果长度不同，记录增减情况
            if len(target_text) > len(source_text):
                changes.append(f"内容增加: {len(target_text) - len(source_text)} 字符")
            elif len(target_text) < len(source_text):
                changes.append(f"内容减少: {len(source_text) - len(target_text)} 字符")
            
            # 比较图片数量
            source_images = len(source_soup.find_all('img'))
            target_images = len(target_soup.find_all('img'))
            if source_images != target_images:
                if target_images > source_images:
                    changes.append(f"添加了 {target_images - source_images} 张图片")
                else:
                    changes.append(f"删除了 {source_images - target_images} 张图片")
            
            # 比较链接数量
            source_links = len(source_soup.find_all('a'))
            target_links = len(target_soup.find_all('a'))
            if source_links != target_links:
                if target_links > source_links:
                    changes.append(f"添加了 {target_links - source_links} 个链接")
                else:
                    changes.append(f"删除了 {source_links - target_links} 个链接")
            
            # 比较表格数量
            source_tables = len(source_soup.find_all('table'))
            target_tables = len(target_soup.find_all('table'))
            if source_tables != target_tables:
                if target_tables > source_tables:
                    changes.append(f"添加了 {target_tables - source_tables} 个表格")
                else:
                    changes.append(f"删除了 {source_tables - target_tables} 个表格")
            
            # 比较代码块数量
            source_code = len(source_soup.find_all('code'))
            target_code = len(target_soup.find_all('code'))
            if source_code != target_code:
                if target_code > source_code:
                    changes.append(f"添加了 {target_code - source_code} 个代码块")
                else:
                    changes.append(f"删除了 {source_code - target_code} 个代码块")
            
            # 使用difflib比较文本差异
            from difflib import SequenceMatcher
            matcher = SequenceMatcher(None, source_text, target_text)
            
            # 获取详细的修改内容
            for tag, i1, i2, j1, j2 in matcher.get_opcodes():
                if tag == 'replace':
                    changes.append(f"修改: '{source_text[i1:i2]}' 改为 '{target_text[j1:j2]}'")
                elif tag == 'delete':
                    changes.append(f"删除: '{source_text[i1:i2]}'")
                elif tag == 'insert':
                    changes.append(f"添加: '{target_text[j1:j2]}'")
            
            return {'changes': ' | '.join(changes) if changes else '格式修改'}
            
        except Exception as e:
            print(f"获取页面差异时发生错误：{str(e)}")
            return {'changes': f'获取差异失败: {str(e)}'}

    def _process_content_diff(self, page_id: str, current_version: int, previous_version: int) -> str:
        """
        处理内容差异
        
        Args:
            page_id: 页面ID
            current_version: 当前版本号
            previous_version: 上一个版本号
            
        Returns:
            str: 格式化的差异描述
        """
        diff_result = self.client.get_content_diff(page_id, previous_version, current_version)
        return diff_result.get('changes', '无法获取修改内容')

class UpdateRecord:
    """更新记录处理类"""
    
    def __init__(self, confluence_client: ConfluenceClient):
        """
        初始化更新记录处理器
        
        Args:
            confluence_client: Confluence客户端实例
        """
        self.client = confluence_client
        self.updates = []
        self._lock = threading.Lock()
        self._update_queue = Queue()
    
    def _safe_append_update(self, update: Dict) -> None:
        """
        线程安全地添加更新记录
        
        Args:
            update: 更新记录字典
        """
        with self._lock:
            self.updates.append(update)
    
    def process_pages_parallel(self, pages: List[Dict], max_workers: int = 4) -> None:
        """
        并行处理多个页面的历史记录
        
        Args:
            pages: 页面信息列表
            max_workers: 最大并行工作线程数
        """
        with concurrent.futures.ThreadPoolExecutor(max_workers=max_workers) as executor:
            # 使用tqdm显示进度
            list(tqdm(
                executor.map(self.process_page_history, pages),
                total=len(pages),
                desc="处理页面历史"
            ))
        
        # 处理队列中的所有更新记录
        while not self._update_queue.empty():
            update = self._update_queue.get()
            self.updates.append(update)
    
    def process_page_history(self, page: Dict) -> None:
        """
        处理单个页面的历史记录
        
        Args:
            page: 页面信息字典
        """
        try:
            # 获取页面历史记录
            history = self.client.get_page_history(page['id'])
            if not history:
                return
            
            updates_batch = []
            
            # 处理创建记录
            if 'createdBy' in history and 'createdDate' in history:
                created_date = self._parse_date(history['createdDate'])
                updates_batch.append({
                    'page_title': page['title'],
                    'page_id': page['id'],
                    'modifier': history['createdBy']['displayName'],
                    'modified_time': created_date,
                    'version': 1,
                    'page_url': f"{self.client.config.url}pages/viewpage.action?pageId={page['id']}",
                    'action': '创建',
                    'change_content': '创建页面'
                })
            
            # 获取所有版本信息
            if 'lastUpdated' in history:
                last_version = history['lastUpdated']['number']
                
                # 如果有多个版本，获取差异
                if last_version > 1:
                    # 获取版本差异
                    change_content = self.client.get_content_diff(
                        page['id'],
                        last_version - 1,  # 上一个版本
                        last_version       # 当前版本
                    ).get('changes', '无法获取修改内容')
                    
                    updates_batch.append({
                        'page_title': page['title'],
                        'page_id': page['id'],
                        'modifier': history['lastUpdated']['by']['displayName'],
                        'modified_time': self._parse_date(history['lastUpdated']['when']),
                        'version': last_version,
                        'page_url': f"{self.client.config.url}pages/viewpage.action?pageId={page['id']}",
                        'action': '更新',
                        'change_content': change_content
                    })
            
            # 批量添加更新记录
            for update in updates_batch:
                self._update_queue.put(update)
                
        except Exception as e:
            print(f"处理页面 '{page.get('title', 'Unknown')}' 的历史记录时出错: {str(e)}")
    
    @staticmethod
    def _parse_date(date_str: str) -> datetime.datetime:
        """解析日期字符串"""
        return datetime.datetime.strptime(date_str.split('.')[0], "%Y-%m-%dT%H:%M:%S")
    
    def get_sorted_updates(self) -> List[Dict]:
        """获取排序后的更新记录"""
        return sorted(self.updates, key=lambda x: x['modified_time'], reverse=True)

class ExcelExporter:
    """Excel导出类"""
    
    def __init__(self, updates: List[Dict]):
        """
        初始化Excel导出器
        
        Args:
            updates: 更新记录列表
        """
        self.updates = updates
        current_time = datetime.datetime.now().strftime("%Y%m%d_%H%M%S")
        self.output_dir = f"confluence_exports_{current_time}"
        os.makedirs(self.output_dir, exist_ok=True)
    
    def _clean_data(self) -> List[Dict]:
        """
        清洗数据，合并同一天内同一个人对同一页面的多次修改
        
        Returns:
            List[Dict]: 清洗后的数据列表
        """
        # 按页面ID和修改者分组
        grouped_updates = {}
        for update in self.updates:
            date = update['modified_time'].date()
            key = (update['page_id'], update['modifier'], date)
            
            if key not in grouped_updates:
                grouped_updates[key] = {
                    'page_title': update['page_title'],
                    'page_id': update['page_id'],
                    'modifier': update['modifier'],
                    'modified_time': update['modified_time'],
                    'version': update['version'],
                    'page_url': update['page_url'],
                    'action': update['action'],
                    'update_count': 1,
                    'change_content': [update['change_content']]
                }
            else:
                # 更新最新的修改时间和版本号
                if update['modified_time'] > grouped_updates[key]['modified_time']:
                    grouped_updates[key]['modified_time'] = update['modified_time']
                    grouped_updates[key]['version'] = update['version']
                grouped_updates[key]['update_count'] += 1
                grouped_updates[key]['change_content'].append(update['change_content'])
                
                # 如果有创建操作，优先使用创建操作
                if update['action'] == '创建':
                    grouped_updates[key]['action'] = '创建'
        
        # 将分组后的数据转换为列表
        cleaned_updates = []
        for update in grouped_updates.values():
            # 合并修改内容
            update['change_content'] = ' || '.join(update['change_content'])
            
            # 修改action显示格式
            if update['update_count'] > 1:
                if update['action'] == '创建':
                    update['action'] = f'创建并修改{update["update_count"]-1}次'
                else:
                    update['action'] = f'修改{update["update_count"]}次'
            
            cleaned_updates.append(update)
        
        return cleaned_updates
    
    def _filter_by_month(self, data: List[Dict], year: int, month: int) -> List[Dict]:
        """
        按月份筛选数据
        
        Args:
            data: 要筛选的数据列表
            year: 年份
            month: 月份
            
        Returns:
            List[Dict]: 筛选后的数据列表
        """
        return [
            item for item in data
            if item['modified_time'].year == year and item['modified_time'].month == month
        ]
    
    def export(self, target_year: int = None, target_month: int = None) -> Tuple[str, str, str]:
        """
        导出更新记录到Excel文件
        
        Args:
            target_year: 指定年份，如果为None则使用当前年份
            target_month: 指定月份（1-12），如果为None则使用当前月份
            
        Returns:
            Tuple[str, str, str]: 导出的三个文件路径（详细记录、汇总记录、指定月份记录）
        """
        # 如果未指定年月，使用当前年月
        if target_year is None or target_month is None:
            current_date = datetime.datetime.now()
            target_year = current_date.year
            target_month = current_date.month
        
        # 验证月份有效性
        if not (1 <= target_month <= 12):
            raise ValueError("月份必须在1到12之间")
        
        # 创建基础DataFrame
        df_detailed = pd.DataFrame(self.updates)
        cleaned_data = self._clean_data()
        df_cleaned = pd.DataFrame(cleaned_data)
        
        # 获取指定月份的数据
        monthly_data = self._filter_by_month(cleaned_data, target_year, target_month)
        df_monthly = pd.DataFrame(monthly_data)
        
        # 重命名列
        column_names = {
            'page_title': '页面标题',
            'page_id': '页面ID',
            'modifier': '修改者',
            'modified_time': '修改时间',
            'version': '版本号',
            'page_url': '页面链接',
            'action': '操作类型',
            'change_content': '修改内容'
        }
        df_detailed = df_detailed.rename(columns=column_names)
        df_cleaned = df_cleaned.rename(columns=column_names)
        df_monthly = df_monthly.rename(columns=column_names)
        
        # 设置列的显示顺序
        columns_order = ['页面标题', '操作类型', '修改者', '修改时间', '版本号', '页面链接', '页面ID', '修改内容']
        df_detailed = df_detailed[columns_order]
        df_cleaned = df_cleaned[columns_order]
        df_monthly = df_monthly[columns_order]
        
        # 生成文件名
        current_time = datetime.datetime.now().strftime("%Y%m%d_%H%M%S")
        detailed_file = os.path.join(self.output_dir, f"软件IP认证所更新记录_详细_{current_time}.xlsx")
        cleaned_file = os.path.join(self.output_dir, f"软件IP认证所更新记录_汇总_{current_time}.xlsx")
        monthly_file = os.path.join(self.output_dir, f"软件IP认证所更新记录_{target_year}年{target_month:02d}月_{current_time}.xlsx")
        
        # 保存到Excel
        df_detailed.to_excel(detailed_file, index=False, engine='openpyxl')
        df_cleaned.to_excel(cleaned_file, index=False, engine='openpyxl')
        df_monthly.to_excel(monthly_file, index=False, engine='openpyxl')
        
        # 格式化Excel
        self._format_excel(detailed_file)
        self._format_excel(cleaned_file)
        self._format_excel(monthly_file)
        
        return detailed_file, cleaned_file, monthly_file
    
    def _format_excel(self, excel_file: str) -> None:
        """
        格式化Excel文件
        
        Args:
            excel_file: Excel文件路径
        """
        from openpyxl import load_workbook
        from openpyxl.styles import PatternFill, Font, Alignment
        
        wb = load_workbook(excel_file)
        ws = wb.active
        
        # 设置列宽
        column_widths = {
            'A': 40,  # 页面标题
            'B': 16,  # 操作类型
            'C': 15,  # 修改者
            'D': 20,  # 修改时间
            'E': 10,  # 版本号
            'F': 70,  # 页面链接
            'G': 15,  # 页面ID
            'H': 100  # 修改内容
        }
        
        for col, width in column_widths.items():
            ws.column_dimensions[col].width = width
        
        # 设置标题行样式
        header_fill = PatternFill(start_color="CCE5FF", end_color="CCE5FF", fill_type="solid")
        header_font = Font(bold=True)
        
        for cell in ws[1]:
            cell.fill = header_fill
            cell.font = header_font
            cell.alignment = Alignment(horizontal='center')
        
        # 设置数据行的对齐方式
        for row in ws.iter_rows(min_row=2):
            for cell in row:
                if isinstance(cell.value, str):
                    cell.alignment = Alignment(horizontal='left')
                else:
                    cell.alignment = Alignment(horizontal='center')
        
        wb.save(excel_file)

    def export_multiple_months(self, year: int = None, months: List[int] = None) -> List[str]:
        """
        导出多个月份的更新记录
        
        Args:
            year: 指定年份，如果为None则使用当前年份
            months: 月份列表，如果为None则导出所有月份
            
        Returns:
            List[str]: 导出的文件路径列表
        """
        if year is None:
            year = datetime.datetime.now().year
            
        if months is None:
            # 如果是当前年份，只导出到当前月份
            if year == datetime.datetime.now().year:
                months = list(range(1, datetime.datetime.now().month + 1))
            else:
                months = list(range(1, 13))
        
        # 创建基础DataFrame
        df_detailed = pd.DataFrame(self.updates)
        cleaned_data = self._clean_data()
        df_cleaned = pd.DataFrame(cleaned_data)
        
        # 生成详细和汇总记录
        current_time = datetime.datetime.now().strftime("%Y%m%d_%H%M%S")
        detailed_file = os.path.join(self.output_dir, f"软件IP认证所更新记录_详细_{current_time}.xlsx")
        cleaned_file = os.path.join(self.output_dir, f"软件IP认证所更新记录_汇总_{current_time}.xlsx")
        
        # 重命名列
        column_names = {
            'page_title': '页面标题',
            'page_id': '页面ID',
            'modifier': '修改者',
            'modified_time': '修改时间',
            'version': '版本号',
            'page_url': '页面链接',
            'action': '操作类型',
            'change_content': '修改内容'
        }
        
        # 设置列的显示顺序
        columns_order = ['页面标题', '操作类型', '修改者', '修改时间', '版本号', '页面链接', '页面ID', '修改内容']
        
        df_detailed = df_detailed.rename(columns=column_names)[columns_order]
        df_cleaned = df_cleaned.rename(columns=column_names)[columns_order]
        
        # 保存详细和汇总记录
        df_detailed.to_excel(detailed_file, index=False, engine='openpyxl')
        df_cleaned.to_excel(cleaned_file, index=False, engine='openpyxl')
        
        # 格式化Excel
        self._format_excel(detailed_file)
        self._format_excel(cleaned_file)
        
        # 导出每个月的数据
        monthly_files = []
        for month in months:
            monthly_data = self._filter_by_month(cleaned_data, year, month)
            if monthly_data:  # 只有当月份有数据时才创建文件
                df_monthly = pd.DataFrame(monthly_data)
                df_monthly = df_monthly.rename(columns=column_names)[columns_order]
                
                monthly_file = os.path.join(
                    self.output_dir, 
                    f"软件IP认证所更新记录_{year}年{month:02d}月_{current_time}.xlsx"
                )
                
                df_monthly.to_excel(monthly_file, index=False, engine='openpyxl')
                self._format_excel(monthly_file)
                monthly_files.append(monthly_file)
        
        return [detailed_file, cleaned_file] + monthly_files

def main():
    """主函数"""
    # 创建命令行参数解析器
    parser = argparse.ArgumentParser(description='获取Confluence空间的更新记录和结构')
    parser.add_argument('--year', type=int, help='指定年份（例如：2024）')
    parser.add_argument('--month', type=int, help='指定月份（1-12）')
    parser.add_argument('--workers', type=int, default=4, help='并行处理的工作线程数（默认：4）')
    
    args = parser.parse_args()
    
    try:
        # 从配置文件加载配置
        config = ConfluenceConfig.from_json()
        
        # 初始化Confluence客户端
        client = ConfluenceClient(config)
        
        # 获取空间信息
        print("获取空间信息...")
        space_info = client.get_space_info()
        
        # 获取更新记录
        print("\n获取空间页面列表...")
        pages = client.get_all_pages()
        total_pages = len(pages)
        print(f"找到 {total_pages} 个页面")
        
        if not pages:
            print("未找到任何页面")
            return
        
        # 处理更新记录
        print("\n处理页面历史记录...")
        record_processor = UpdateRecord(client)
        record_processor.process_pages_parallel(pages, max_workers=args.workers)
        
        updates = record_processor.get_sorted_updates()
        
        if not updates:
            print("未找到任何更新记录")
            return
        
        # 导出到Excel
        print("\n导出数据...")
        exporter = ExcelExporter(updates)
        
        # 设置输出目录
        client.set_output_dir(exporter.output_dir)
        
        # 打印空间的树形结构
        print("\n生成树形结构...")
        tree_file, tree_with_count_file = client.get_page_tree()
        if tree_file:
            print(f"基础树形结构已保存到文件：{os.path.abspath(tree_file)}")
            print(f"带节点计数的树形结构已保存到文件：{os.path.abspath(tree_with_count_file)}")
        
        # 根据参数决定如何导出数据
        if args.year and args.month:
            # 导出指定年月的数据
            detailed_file, cleaned_file, monthly_file = exporter.export(args.year, args.month)
            print(f"\n更新记录已保存到文件：{os.path.abspath(detailed_file)}")
            print(f"汇总记录已保存到文件：{os.path.abspath(cleaned_file)}")
            print(f"{args.year}年{args.month}月的记录已保存到文件：{os.path.abspath(monthly_file)}")
        else:
            # 导出多个月份的数据
            year = args.year if args.year else datetime.datetime.now().year
            files = exporter.export_multiple_months(year)
            
            print(f"\n更新记录已保存到文件：{os.path.abspath(files[0])}")
            print(f"汇总记录已保存到文件：{os.path.abspath(files[1])}")
            
            if len(files) > 2:
                print("\n月度记录已保存到以下文件：")
                for file in files[2:]:
                    print(os.path.abspath(file))
    
    except Exception as e:
        print(f"程序运行出错: {str(e)}")
        return

if __name__ == "__main__":
    main()
